const axios = require('axios');

// 基础URL配置
const BASE_URL = 'http://localhost:3000/api';
const AUTH_URL = `${BASE_URL}/auth`;
const MODEL_URL = `${BASE_URL}/models`;

// 测试用户凭据
const TEST_USER = {
    username: 'admin',
    password: '123456',
    email: '525675049@qq.com'
};

// 全局变量
let accessToken = '';
let testModelId = '';

// 控制台日志颜色
const colors = {
    reset: '\x1b[0m',
    green: '\x1b[32m',
    red: '\x1b[31m',
    yellow: '\x1b[33m',
    blue: '\x1b[34m',
    magenta: '\x1b[35m'
};

/**
 * 格式化日志输出
 */
function logSection(title) {
    console.log(`\n${colors.magenta}===== ${title} =====${colors.reset}`);
}

function logSuccess(message) {
    console.log(`${colors.green}✅ ${message}${colors.reset}`);
}

function logError(message, error) {
    console.log(`${colors.red}❌ ${message}${colors.reset}`);
    if (error.response) {
        console.log(`状态码: ${error.response.status}`);
        console.log(`错误信息:`, error.response.data);
    } else if (error.request) {
        console.log('无法连接到服务器，请确保服务器正在运行');
    } else {
        console.log(`请求错误: ${error.message}`);
    }
}

function logInfo(message) {
    console.log(`${colors.blue}ℹ️ ${message}${colors.reset}`);
}

/**
 * 注册测试用户
 */
async function registerTestUser() {
    logSection('注册测试用户');

    try {
        await axios.post(`${AUTH_URL}/register`, TEST_USER);
        logSuccess(`用户 "${TEST_USER.username}" 注册成功`);
        return true;
    } catch (error) {
        if (error.response && error.response.status === 409) {
            logInfo(`用户 "${TEST_USER.username}" 已存在，继续测试`);
            return true;
        }
        logError('注册测试用户失败', error);
        return false;
    }
}

/**
 * 登录测试用户
 */
async function loginTestUser() {
    logSection('登录测试用户');

    try {
        const response = await axios.post(`${AUTH_URL}/login`, {
            username: TEST_USER.username,
            password: TEST_USER.password
        });

        accessToken = response.data.data.token;
        logSuccess(`用户 "${TEST_USER.username}" 登录成功`);
        logInfo(`访问令牌: ${accessToken.substring(0, 15)}...`);
        return true;
    } catch (error) {
        logError('登录测试用户失败', error);
        return false;
    }
}

/**
 * 获取模型列表
 */
async function getModels() {
    logSection('获取模型列表');

    try {
        const response = await axios.get(MODEL_URL, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        logSuccess('获取模型列表成功');
        console.log('模型列表:', response.data.data);
        return response.data.data;
    } catch (error) {
        logError('获取模型列表失败', error);
        return null;
    }
}

/**
 * 创建测试模型
 */
async function createTestModel() {
    logSection('创建测试模型');

    const modelData = {
        name: '测试3D模型',
        description: '这是一个用于API测试的3D模型'
    };

    try {
        const response = await axios.post(MODEL_URL, modelData, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        testModelId = response.data.data.modelId;
        logSuccess('创建测试模型成功');
        logInfo(`模型ID: ${testModelId}`);
        console.log('响应数据:', response.data);
        return true;
    } catch (error) {
        logError('创建测试模型失败', error);
        return false;
    }
}

/**
 * 更新测试模型
 */
async function updateTestModel() {
    logSection('更新测试模型');

    if (!testModelId) {
        logError('无法更新模型，模型ID不存在');
        return false;
    }

    const updateData = {
        name: '更新后的测试模型',
        description: '这是一个已更新的测试模型描述'
    };

    try {
        const response = await axios.put(`${MODEL_URL}/${testModelId}`, updateData, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        logSuccess('更新测试模型成功');
        console.log('响应数据:', response.data);
        return true;
    } catch (error) {
        logError('更新测试模型失败', error);
        return false;
    }
}

/**
 * 删除测试模型
 */
async function deleteTestModel() {
    logSection('删除测试模型');

    if (!testModelId) {
        logError('无法删除模型，模型ID不存在');
        return false;
    }

    try {
        const response = await axios.delete(`${MODEL_URL}/${testModelId}`, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        logSuccess('删除测试模型成功');
        console.log('响应数据:', response.data);
        return true;
    } catch (error) {
        logError('删除测试模型失败', error);
        return false;
    }
}

/**
 * 运行所有测试
 */
async function runAllTests() {
    console.log(`${colors.yellow}开始3D模型API测试...${colors.reset}`);

    // 准备测试环境
    const isRegistered = await registerTestUser();
    if (!isRegistered) return;

    const isLoggedIn = await loginTestUser();
    if (!isLoggedIn) return;

    // 测试获取模型列表（初始状态）
    await getModels();

    // 测试创建模型
    const isCreated = await createTestModel();
    if (!isCreated) return;

    // 测试获取模型列表（应该包含新创建的模型）
    await getModels();

    // 测试更新模型
    await updateTestModel();

    // 测试获取模型列表（应显示更新后的模型）
    await getModels();

    // 测试删除模型
    await deleteTestModel();

    // 测试获取模型列表（应该不包含已删除的模型）
    await getModels();

    console.log(`\n${colors.green}所有测试完成！${colors.reset}`);
}

// 执行测试
runAllTests().catch(error => {
    console.error(`${colors.red}测试过程中出现未捕获的错误:${colors.reset}`, error);
}); 